{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [对 Stack Overflow 问题进行多类分类](https://www.tensorflow.org/tutorials/keras/text_classification?hl=zh-cn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2025-01-22 08:55:51.117062: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "import re\n",
    "import shutil\n",
    "import string\n",
    "import tensorflow as tf\n",
    "\n",
    "from tensorflow.keras import layers\n",
    "from tensorflow.keras import losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.13.0\n"
     ]
    }
   ],
   "source": [
    "print(tf.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "url = \"https://storage.googleapis.com/download.tensorflow.org/data/stack_overflow_16k.tar.gz\"\n",
    "\n",
    "dataset = tf.keras.utils.get_file(\"stack_overflow\", url,\n",
    "                                    untar=True, cache_dir='./data',\n",
    "                                    cache_subdir='stack_overflow')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "./data/stack_overflow\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['stack_overflow.tar.gz', 'README.md', 'train', 'test']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(os.path.dirname(dataset))\n",
    "\n",
    "# dataset_dir = os.path.join(os.path.dirname(dataset), 'stack_overflow')\n",
    "dataset_dir = os.path.dirname(dataset)\n",
    "os.listdir(dataset_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['python', 'java', 'csharp', 'javascript']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_dir = os.path.join(dataset_dir, 'train')\n",
    "os.listdir(train_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"add version to @@webservice i'm using blankx.jws.webservice to create my webservice, in addition to targetnamespace i would like to include a \"\"version\"\" attribute to mark the version of my service. what other tag can i use in addition to this one to accomplish this so my wdsl will look like:..&lt;schema targetnamespace=\"\"http://example.com/2009/02/15/webservice\"\" version=\"\"1.1\"\" xmlns=\"\"http://www.w3.org/2000/10/xmlschema&gt;...i.e. it has a version attribute\"\n",
      "\n"
     ]
    }
   ],
   "source": [
    "sample_file = os.path.join(train_dir, 'java/1.txt')\n",
    "with open(sample_file) as f:\n",
    "  print(f.read())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# remove_dir = os.path.join(train_dir, 'unsup')\n",
    "# shutil.rmtree(remove_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 8000 files belonging to 4 classes.\n",
      "Using 6400 files for training.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2025-01-22 08:56:03.606510: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1639] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 1177 MB memory:  -> device: 0, name: NVIDIA GeForce RTX 3060, pci bus id: 0000:09:00.0, compute capability: 8.6\n"
     ]
    }
   ],
   "source": [
    "batch_size = 32\n",
    "seed = 42\n",
    "\n",
    "raw_train_ds = tf.keras.utils.text_dataset_from_directory(\n",
    "    f'{dataset_dir}/train', \n",
    "    batch_size=batch_size, \n",
    "    validation_split=0.2, \n",
    "    subset='training', \n",
    "    seed=seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Review b'\"my tester is going to the wrong constructor i am new to programming so if i ask a question that can be easily fixed, please forgive me. my program has a tester class with a main. when i send that to my regularpolygon class, it sends it to the wrong constructor. i have two constructors. 1 without perameters..public regularpolygon().    {.       mynumsides = 5;.       mysidelength = 30;.    }//end default constructor...and my second, with perameters. ..public regularpolygon(int numsides, double sidelength).    {.        mynumsides = numsides;.        mysidelength = sidelength;.    }// end constructor...in my tester class i have these two lines:..regularpolygon shape = new regularpolygon(numsides, sidelength);.        shape.menu();...numsides and sidelength were declared and initialized earlier in the testing class...so what i want to happen, is the tester class sends numsides and sidelength to the second constructor and use it in that class. but it only uses the default constructor, which therefor ruins the whole rest of the program. can somebody help me?..for those of you who want to see more of my code: here you go..public double vertexangle().    {.        system.out.println(\"\"the vertex angle method: \"\" + mynumsides);// prints out 5.        system.out.println(\"\"the vertex angle method: \"\" + mysidelength); // prints out 30..        double vertexangle;.        vertexangle = ((mynumsides - 2.0) / mynumsides) * 180.0;.        return vertexangle;.    }//end method vertexangle..public void menu().{.    system.out.println(mynumsides); // prints out what the user puts in.    system.out.println(mysidelength); // prints out what the user puts in.    gotographic();.    calcr(mynumsides, mysidelength);.    calcr(mynumsides, mysidelength);.    print(); .}// end menu...this is my entire tester class:..public static void main(string[] arg).{.    int numsides;.    double sidelength;.    scanner keyboard = new scanner(system.in);..    system.out.println(\"\"welcome to the regular polygon program!\"\");.    system.out.println();..    system.out.print(\"\"enter the number of sides of the polygon ==&gt; \"\");.    numsides = keyboard.nextint();.    system.out.println();..    system.out.print(\"\"enter the side length of each side ==&gt; \"\");.    sidelength = keyboard.nextdouble();.    system.out.println();..    regularpolygon shape = new regularpolygon(numsides, sidelength);.    shape.menu();.}//end main...for testing it i sent it numsides 4 and sidelength 100.\"\\n'\n",
      "Label 1\n",
      "Review b'\"blank code slow skin detection this code changes the color space to lab and using a threshold finds the skin area of an image. but it\\'s ridiculously slow. i don\\'t know how to make it faster ?    ..from colormath.color_objects import *..def skindetection(img, treshold=80, color=[255,20,147]):..    print img.shape.    res=img.copy().    for x in range(img.shape[0]):.        for y in range(img.shape[1]):.            rgbimg=rgbcolor(img[x,y,0],img[x,y,1],img[x,y,2]).            labimg=rgbimg.convert_to(\\'lab\\', debug=false).            if (labimg.lab_l &gt; treshold):.                res[x,y,:]=color.            else: .                res[x,y,:]=img[x,y,:]..    return res\"\\n'\n",
      "Label 3\n",
      "Review b'\"option and validation in blank i want to add a new option on my system where i want to add two text files, both rental.txt and customer.txt. inside each text are id numbers of the customer, the videotape they need and the price...i want to place it as an option on my code. right now i have:...add customer.rent return.view list.search.exit...i want to add this as my sixth option. say for example i ordered a video, it would display the price and would let me confirm the price and if i am going to buy it or not...here is my current code:..  import blank.io.*;.    import blank.util.arraylist;.    import static blank.lang.system.out;..    public class rentalsystem{.    static bufferedreader input = new bufferedreader(new inputstreamreader(system.in));.    static file file = new file(\"\"file.txt\"\");.    static arraylist&lt;string&gt; list = new arraylist&lt;string&gt;();.    static int rows;..    public static void main(string[] args) throws exception{.        introduction();.        system.out.print(\"\"nn\"\");.        login();.        system.out.print(\"\"nnnnnnnnnnnnnnnnnnnnnn\"\");.        introduction();.        string repeat;.        do{.            loadfile();.            system.out.print(\"\"nwhat do you want to do?nn\"\");.            system.out.print(\"\"n                    - - - - - - - - - - - - - - - - - - - - - - -\"\");.            system.out.print(\"\"nn                    |     1. add customer    |   2. rent return |n\"\");.            system.out.print(\"\"n                    - - - - - - - - - - - - - - - - - - - - - - -\"\");.            system.out.print(\"\"nn                    |     3. view list       |   4. search      |n\"\");.            system.out.print(\"\"n                    - - - - - - - - - - - - - - - - - - - - - - -\"\");.            system.out.print(\"\"nn                                             |   5. exit        |n\"\");.            system.out.print(\"\"n                                              - - - - - - - - - -\"\");.            system.out.print(\"\"nnchoice:\"\");.            int choice = integer.parseint(input.readline());.            switch(choice){.                case 1:.                    writedata();.                    break;.                case 2:.                    rentdata();.                    break;.                case 3:.                    viewlist();.                    break;.                case 4:.                    search();.                    break;.                case 5:.                    system.out.println(\"\"goodbye!\"\");.                    system.exit(0);.                default:.                    system.out.print(\"\"invalid choice: \"\");.                    break;.            }.            system.out.print(\"\"ndo another task? [y/n] \"\");.            repeat = input.readline();.        }while(repeat.equals(\"\"y\"\"));..        if(repeat!=\"\"y\"\") system.out.println(\"\"ngoodbye!\"\");..    }..    public static void writedata() throws exception{.        system.out.print(\"\"nname: \"\");.        string cname = input.readline();.        system.out.print(\"\"address: \"\");.        string add = input.readline();.        system.out.print(\"\"phone no.: \"\");.        string pno = input.readline();.        system.out.print(\"\"rental amount: \"\");.        string ramount = input.readline();.        system.out.print(\"\"tapenumber: \"\");.        string tno = input.readline();.        system.out.print(\"\"title: \"\");.        string title = input.readline();.        system.out.print(\"\"date borrowed: \"\");.        string dborrowed = input.readline();.        system.out.print(\"\"due date: \"\");.        string ddate = input.readline();.        createline(cname, add, pno, ramount,tno, title, dborrowed, ddate);.        rentdata();.    }..    public static void createline(string name, string address, string phone , string rental, string tapenumber, string title, string borrowed, string due) throws exception{.        filewriter fw = new filewriter(file, true);.        fw.write(\"\"nname: \"\"+name + \"\"naddress: \"\" + address +\"\"nphone no.: \"\"+ phone+\"\"nrentalamount: \"\"+rental+\"\"ntape no.: \"\"+ tapenumber+\"\"ntitle: \"\"+ title+\"\"ndate borrowed: \"\"+borrowed +\"\"ndue date: \"\"+ due+\"\":rn\"\");.        fw.close();.    }..    public static void loadfile() throws exception{.        try{.            list.clear();.            fileinputstream fstream = new fileinputstream(file);.            bufferedreader br = new bufferedreader(new inputstreamreader(fstream));.            rows = 0;.            while( br.ready()).            {.                list.add(br.readline());.                rows++;.            }.            br.close();.        } catch(exception e){.            system.out.println(\"\"list not yet loaded.\"\");.        }.    }..    public static void viewlist(){.        system.out.print(\"\"n~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~\"\");.        system.out.print(\"\" |list of all costumers|\"\");.        system.out.print(\"\"~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~\"\");.        for(int i = 0; i &lt;rows; i++){.            system.out.println(list.get(i));.        }.    }.        public static void rentdata()throws exception.    {   system.out.print(\"\"n~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~\"\");.        system.out.print(\"\" |rent data list|\"\");.        system.out.print(\"\"~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~\"\");.        system.out.print(\"\"nenter customer name: \"\");.        string cname = input.readline();.        system.out.print(\"\"date borrowed: \"\");.        string dborrowed = input.readline();.        system.out.print(\"\"due date: \"\");.        string ddate = input.readline();.        system.out.print(\"\"return date: \"\");.        string rdate = input.readline();.        system.out.print(\"\"rent amount: \"\");.        string ramount = input.readline();..        system.out.print(\"\"you pay:\"\"+ramount);...    }.    public static void search()throws exception.    {   system.out.print(\"\"n~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~\"\");.        system.out.print(\"\" |search costumers|\"\");.        system.out.print(\"\"~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~\"\");.        system.out.print(\"\"nenter costumer name: \"\");.        string cname = input.readline();.        boolean found = false;..        for(int i=0; i &lt; rows; i++){.            string temp[] = list.get(i).split(\"\",\"\");..            if(cname.equals(temp[0])){.            system.out.println(\"\"search result:nyou are \"\" + temp[0] + \"\" from \"\" + temp[1] + \"\".\"\"+ temp[2] + \"\".\"\"+ temp[3] + \"\".\"\"+ temp[4] + \"\".\"\"+ temp[5] + \"\" is \"\" + temp[6] + \"\".\"\"+ temp[7] + \"\" is \"\" + temp[8] + \"\".\"\");.                found = true;.            }.        }..        if(!found){.            system.out.print(\"\"no results.\"\");.        }..    }..        public static boolean evaluate(string uname, string pass){.        if (uname.equals(\"\"admin\"\")&amp;&amp;pass.equals(\"\"12345\"\")) return true;.        else return false;.    }..    public static string login()throws exception{.        bufferedreader input=new bufferedreader(new inputstreamreader(system.in));.        int counter=0;.        do{.            system.out.print(\"\"username:\"\");.            string uname =input.readline();.            system.out.print(\"\"password:\"\");.            string pass =input.readline();..            boolean accept= evaluate(uname,pass);..            if(accept){.                break;.                }else{.                    system.out.println(\"\"incorrect username or password!\"\");.                    counter ++;.                    }.        }while(counter&lt;3);..            if(counter !=3) return \"\"login successful\"\";.            else return \"\"login failed\"\";.            }.        public static void introduction() throws exception{..        system.out.println(\"\"                  - - - - - - - - - - - - - - - - - - - - - - - - -\"\");.        system.out.println(\"\"                  !                  r e n t a l                  !\"\");.        system.out.println(\"\"                   ! ~ ~ ~ ~ ~ !  =================  ! ~ ~ ~ ~ ~ !\"\");.        system.out.println(\"\"                  !                  s y s t e m                  !\"\");.        system.out.println(\"\"                  - - - - - - - - - - - - - - - - - - - - - - - - -\"\");.        }..}\"\\n'\n",
      "Label 1\n"
     ]
    }
   ],
   "source": [
    "for text_batch, label_batch in raw_train_ds.take(1):\n",
    "    for i in range(3):\n",
    "        print(\"Review\", text_batch.numpy()[i])\n",
    "        print(\"Label\", label_batch.numpy()[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Label 0 corresponds to csharp\n",
      "Label 1 corresponds to java\n"
     ]
    }
   ],
   "source": [
    "print(\"Label 0 corresponds to\", raw_train_ds.class_names[0])\n",
    "print(\"Label 1 corresponds to\", raw_train_ds.class_names[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 8000 files belonging to 4 classes.\n",
      "Using 1600 files for validation.\n"
     ]
    }
   ],
   "source": [
    "raw_val_ds = tf.keras.utils.text_dataset_from_directory(\n",
    "    f'{dataset_dir}/train', \n",
    "    batch_size=batch_size, \n",
    "    validation_split=0.2, \n",
    "    subset='validation', \n",
    "    seed=seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 8000 files belonging to 4 classes.\n"
     ]
    }
   ],
   "source": [
    "raw_test_ds = tf.keras.utils.text_dataset_from_directory(\n",
    "    f'{dataset_dir}/test', \n",
    "    batch_size=batch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来，您将使用有用的 tf.keras.layers.TextVectorization 层对数据进行标准化、词例化和向量化。\n",
    "\n",
    "标准化是指对文本进行预处理，通常是移除标点符号或 HTML 元素以简化数据集。词例化是指将字符串分割成词例（例如，通过空格将句子分割成单个单词）。向量化是指将词例转换为数字，以便将它们输入神经网络。所有这些任务都可以通过这个层完成。\n",
    "\n",
    "正如您在上面看到的，评论包含各种 HTML 代码，例如 <br />。TextVectorization 层（默认情况下会将文本转换为小写并去除标点符号，但不会去除 HTML）中的默认标准化程序不会移除这些代码。您将编写一个自定义标准化函数来移除 HTML。\n",
    "\n",
    "注：为了防止训练-测试偏差（也称为训练-应用偏差），在训练和测试时间对数据进行相同的预处理非常重要。为此，可以将 TextVectorization 层直接包含在模型中，如本教程后面所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def custom_standardization(input_data):\n",
    "    lowercase = tf.strings.lower(input_data)\n",
    "    stripped_html = tf.strings.regex_replace(lowercase, '<br />', ' ')\n",
    "    return tf.strings.regex_replace(stripped_html,\n",
    "                                    '[%s]' % re.escape(string.punctuation),\n",
    "                                    '')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_features = 10000\n",
    "sequence_length = 250\n",
    "\n",
    "vectorize_layer = layers.TextVectorization(\n",
    "    standardize=custom_standardization,\n",
    "    max_tokens=max_features,\n",
    "    output_mode='int',\n",
    "    output_sequence_length=sequence_length)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make a text-only dataset (without labels), then call adapt\n",
    "train_text = raw_train_ds.map(lambda x, y: x)\n",
    "vectorize_layer.adapt(train_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def vectorize_text(text, label):\n",
    "    text = tf.expand_dims(text, -1)\n",
    "    return vectorize_layer(text), label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Review tf.Tensor(b'\"set blank to quit on exception? i\\'m using blank 3..i\\'ve been looking around for an answer to this, but i haven\\'t found it yet. basically, i\\'m running several blank scripts into a game engine, and each script has its own entry point...i\\'d rather not add try: except blocks through all of my code, so i was wondering if it\\'s at all possible to tell blank to quit (or perhaps assign a custom function to that \"\"callback\"\") on finding its first error, regardless of where or what it found? ..currently, the game engine will continue after finding and hitting an error, making it more difficult than necessary to diagnose issues since running into one error may make a subsequent script not work (as it relies on variables that the error-ing script set, for example). any ideas? ..i know that i could redirect the console to a file to allow for easier scrolling, but just capturing the first error and stopping the game prematurely would be really useful...okay, a couple of extra bits of info - sorry for neglecting to say this. the engine i\\'m using (the blender game engine) is coded in c, so changing the source is more than i\\'d like to do.....after googling, it would appear that a similar question with a solid answer has been asked here, which is how to get the last raised exception. if i check the sys module for the presence of the last_value variable and it exists, then i can quit prematurely, as the console would have already printed out the error...thanks for the help.\"\\n', shape=(), dtype=string)\n",
      "Label python\n",
      "Vectorized review (<tf.Tensor: shape=(1, 250), dtype=int64, numpy=\n",
      "array([[ 107,   16,    4, 1139,   37,  184,   52,   47,   16,    1,  215,\n",
      "         417,  518,   12,   32,  182,    4,   13,   26,    3, 1416,  227,\n",
      "          11,  894,  627,   52,  309,  718,   16, 1274,  100,    5,  244,\n",
      "        1826,    8,  119,  224,   95,   97,  657,  858,    1,  797,   20,\n",
      "         125,  117,  559, 2282,  194,   73,    9,   23,   30,   50,    3,\n",
      "         115,  566,   10,   97,   59,   73,  204,    4,  412,   16,    4,\n",
      "        1139,   45, 1670,  601,    5,  694,   38,    4,   14,  851,   37,\n",
      "         967,   97,   98,   65, 2374,    9,  132,   45,   55,   11,  227,\n",
      "         401,    2,  244, 1826,   72,  534,  156,  967,    8, 7808,   32,\n",
      "          65,  468,   11,  181, 2332,  198, 1461,    4,    1, 1093,  447,\n",
      "         309,  100,   71,   65,  454,  109,    5, 3560,  224,   20,  139,\n",
      "          36,   11, 9052,   37,  233,   14,    2,    1,  224,  107,   12,\n",
      "         137,   76,  779,    3,  102,   14,    3,  176, 1853,    2,  332,\n",
      "           4,    5,   39,    4,  787,   12, 1320, 3579,   26,  106,    1,\n",
      "           2,   98,   65,    8, 2902,    2,  244,    1,   69,   33,  336,\n",
      "           1,    5, 1759,    9, 1157, 2531,    9,  568,  729,   12,    1,\n",
      "           4,  321,   13,    2, 1826,   52,   47,    2,    1,  244, 1826,\n",
      "           6, 2619,    7,  131,   50,  801,    2,  313,    6,  181,  198,\n",
      "         142,   48,    4,    1, 3965,   11,   69,  882,   14,    5,  520,\n",
      "         159,   21,    5, 1706,  182,   95,  215,  912,  101,   66,    6,\n",
      "          24,    4,   41,    2,  218, 2918,  184,   10,    3,  186,    2,\n",
      "        1358,  380,   12,    2, 9151,    9,    2,    1,  116,    8,   11,\n",
      "         758,   87,    3,   35, 1139,    1,   36,    2]])>, <tf.Tensor: shape=(), dtype=int32, numpy=3>)\n"
     ]
    }
   ],
   "source": [
    "# retrieve a batch (of 32 reviews and labels) from the dataset\n",
    "text_batch, label_batch = next(iter(raw_train_ds))\n",
    "first_review, first_label = text_batch[0], label_batch[0]\n",
    "print(\"Review\", first_review)\n",
    "print(\"Label\", raw_train_ds.class_names[first_label])\n",
    "print(\"Vectorized review\", vectorize_text(first_review, first_label))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1287 --->  scissors\n",
      " 313 --->  source\n",
      "Vocabulary size: 10000\n"
     ]
    }
   ],
   "source": [
    "print(\"1287 ---> \",vectorize_layer.get_vocabulary()[1287])\n",
    "print(\" 313 ---> \",vectorize_layer.get_vocabulary()[313])\n",
    "print('Vocabulary size: {}'.format(len(vectorize_layer.get_vocabulary())))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_ds = raw_train_ds.map(vectorize_text)\n",
    "val_ds = raw_val_ds.map(vectorize_text)\n",
    "test_ds = raw_test_ds.map(vectorize_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "AUTOTUNE = tf.data.AUTOTUNE\n",
    "\n",
    "train_ds = train_ds.cache().prefetch(buffer_size=AUTOTUNE)\n",
    "val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)\n",
    "test_ds = test_ds.cache().prefetch(buffer_size=AUTOTUNE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "embedding_dim = 128"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " embedding (Embedding)       (None, None, 128)         1280128   \n",
      "                                                                 \n",
      " dense (Dense)               (None, None, 64)          8256      \n",
      "                                                                 \n",
      " dropout (Dropout)           (None, None, 64)          0         \n",
      "                                                                 \n",
      " global_average_pooling1d (  (None, 64)                0         \n",
      " GlobalAveragePooling1D)                                         \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 32)                2080      \n",
      "                                                                 \n",
      " dropout_1 (Dropout)         (None, 32)                0         \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 4)                 132       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 1290596 (4.92 MB)\n",
      "Trainable params: 1290596 (4.92 MB)\n",
      "Non-trainable params: 0 (0.00 Byte)\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model = tf.keras.Sequential([\n",
    "    layers.Embedding(max_features + 1, embedding_dim),\n",
    "    layers.Dense(64),\n",
    "    layers.Dropout(0.2),\n",
    "    layers.GlobalAveragePooling1D(),\n",
    "    layers.Dense(32),\n",
    "    layers.Dropout(0.2),\n",
    "    layers.Dense(4)])\n",
    "\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(loss=losses.SparseCategoricalCrossentropy(from_logits=True),\n",
    "              optimizer='adam',\n",
    "              metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2025-01-22 08:56:08.634557: I tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:606] TensorFloat-32 will be used for the matrix multiplication. This will only be logged once.\n",
      "2025-01-22 08:56:08.681346: I tensorflow/compiler/xla/service/service.cc:168] XLA service 0x7b766c0 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n",
      "2025-01-22 08:56:08.681389: I tensorflow/compiler/xla/service/service.cc:176]   StreamExecutor device (0): NVIDIA GeForce RTX 3060, Compute Capability 8.6\n",
      "2025-01-22 08:56:08.687642: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:255] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n",
      "2025-01-22 08:56:08.706007: I tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:432] Loaded cuDNN version 8900\n",
      "2025-01-22 08:56:08.883071: I ./tensorflow/compiler/jit/device_compiler.h:186] Compiled cluster using XLA!  This line is logged at most once for the lifetime of the process.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200/200 [==============================] - 40s 190ms/step - loss: 1.2199 - accuracy: 0.4467 - val_loss: 0.8291 - val_accuracy: 0.6587\n",
      "Epoch 2/10\n",
      "200/200 [==============================] - 1s 7ms/step - loss: 0.6517 - accuracy: 0.7420 - val_loss: 0.5905 - val_accuracy: 0.7625\n",
      "Epoch 3/10\n",
      "200/200 [==============================] - 1s 7ms/step - loss: 0.4136 - accuracy: 0.8452 - val_loss: 0.5812 - val_accuracy: 0.7719\n",
      "Epoch 4/10\n",
      "200/200 [==============================] - 1s 7ms/step - loss: 0.2740 - accuracy: 0.9027 - val_loss: 0.6435 - val_accuracy: 0.7769\n",
      "Epoch 5/10\n",
      "200/200 [==============================] - 1s 7ms/step - loss: 0.1836 - accuracy: 0.9372 - val_loss: 0.7600 - val_accuracy: 0.7775\n",
      "Epoch 6/10\n",
      "200/200 [==============================] - 1s 7ms/step - loss: 0.1339 - accuracy: 0.9553 - val_loss: 0.8810 - val_accuracy: 0.7725\n",
      "Epoch 7/10\n",
      "200/200 [==============================] - 1s 7ms/step - loss: 0.1380 - accuracy: 0.9530 - val_loss: 1.0907 - val_accuracy: 0.7500\n",
      "Epoch 8/10\n",
      "200/200 [==============================] - 1s 7ms/step - loss: 0.1036 - accuracy: 0.9639 - val_loss: 0.9302 - val_accuracy: 0.7850\n",
      "Epoch 9/10\n",
      "200/200 [==============================] - 1s 7ms/step - loss: 0.0894 - accuracy: 0.9712 - val_loss: 0.9322 - val_accuracy: 0.7944\n",
      "Epoch 10/10\n",
      "200/200 [==============================] - 1s 7ms/step - loss: 0.0507 - accuracy: 0.9850 - val_loss: 1.0777 - val_accuracy: 0.7862\n"
     ]
    }
   ],
   "source": [
    "epochs = 10\n",
    "history = model.fit(\n",
    "    train_ds,\n",
    "    validation_data=val_ds,\n",
    "    epochs=epochs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  1/250 [..............................] - ETA: 23s - loss: 1.2782 - accuracy: 0.7188"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "250/250 [==============================] - 1s 4ms/step - loss: 1.2249 - accuracy: 0.7650\n",
      "Loss:  1.224892020225525\n",
      "Accuracy:  0.7649999856948853\n"
     ]
    }
   ],
   "source": [
    "loss, accuracy = model.evaluate(test_ds)\n",
    "\n",
    "print(\"Loss: \", loss)\n",
    "print(\"Accuracy: \", accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['loss', 'accuracy', 'val_loss', 'val_accuracy'])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "history_dict = history.history\n",
    "history_dict.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "acc = history_dict['accuracy']\n",
    "val_acc = history_dict['val_accuracy']\n",
    "loss = history_dict['loss']\n",
    "val_loss = history_dict['val_loss']\n",
    "\n",
    "epochs = range(1, len(acc) + 1)\n",
    "\n",
    "# \"bo\" is for \"blue dot\"\n",
    "plt.plot(epochs, loss, 'bo', label='Training loss')\n",
    "# b is for \"solid blue line\"\n",
    "plt.plot(epochs, val_loss, 'b', label='Validation loss')\n",
    "plt.title('Training and validation loss')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(epochs, acc, 'bo', label='Training acc')\n",
    "plt.plot(epochs, val_acc, 'b', label='Validation acc')\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.legend(loc='lower right')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "250/250 [==============================] - 2s 7ms/step - loss: 1.2249 - accuracy: 0.7650\n",
      "0.7649999856948853\n"
     ]
    }
   ],
   "source": [
    "export_model = tf.keras.Sequential([\n",
    "    vectorize_layer,\n",
    "    model,\n",
    "    layers.Activation('sigmoid')\n",
    "])\n",
    "\n",
    "export_model.compile(\n",
    "    loss=losses.SparseCategoricalCrossentropy(from_logits=False), optimizer=\"adam\", metrics=['accuracy']\n",
    ")\n",
    "\n",
    "# Test it with `raw_test_ds`, which yields raw strings\n",
    "loss, accuracy = export_model.evaluate(raw_test_ds)\n",
    "print(accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 251ms/step\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[6.8500417e-04, 1.5524915e-01, 9.7976619e-01, 9.9999964e-01],\n",
       "       [5.6302261e-01, 7.3412061e-01, 7.5603187e-01, 1.9854821e-02]],\n",
       "      dtype=float32)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "ename": "",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m在当前单元格或上一个单元格中执行代码时 Kernel 崩溃。\n",
      "\u001b[1;31m请查看单元格中的代码，以确定故障的可能原因。\n",
      "\u001b[1;31m单击<a href='https://aka.ms/vscodeJupyterKernelCrash'>此处</a>了解详细信息。\n",
      "\u001b[1;31m有关更多详细信息，请查看 Jupyter <a href='command:jupyter.viewOutput'>log</a>。"
     ]
    }
   ],
   "source": [
    "examples = [\n",
    "    \"blank pefile member question gang,..i apologize if this is a really dumb question...  i am wanting to use the super convenient blank script pefile (http://code.google.com/p/pefile/) that parses an executable and lists particular information about the pe structure.  my question is where can i find information about how to access particular members of the executable?  i've scoured the wiki and read the usage examples but that documentation only covered 4-5 members.  what i am wondering is if you guys have a list of members i can access to display the information i care about.  so specifically,  if i wanted to list the stack commit size of an executable, does it look like this: pe.file_header.stackcommitsize, obviously i can run this code and figure it out but have you guys seen api doc floating around that i find the members i need?..thanks!\",\n",
    "    \"how to specify the connection string if the excel file name contains white space?using blank string connstring = \"\"provider=microsoft.ace.oledb.12.0;data source=d:\\data\\[proj_resource details 20110118.xlsx];extended properties=excel 12.0\"\";...i mentioned [ ] still it is throwing exception.how can i solve this problem..plz mention the correct path\",\n",
    "]\n",
    "\n",
    "export_model.predict(examples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
